Add AOT type configuration API

Update tests and add convenience API for registering configurations required to interact with certain types.

See: #2595
Original Pull Request: #3318

Author: christophstrobl

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

@@ -22,14 +22,17 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Consumer;
+import java.util.function.Predicate;
 
 import org.jspecify.annotations.Nullable;
+import org.springframework.aot.hint.TypeReference;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanReference;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.beans.factory.support.RootBeanDefinition;
+import org.springframework.core.ResolvableType;
 import org.springframework.core.env.Environment;
 import org.springframework.core.env.EnvironmentCapable;
 import org.springframework.core.env.StandardEnvironment;
@@ -227,6 +230,20 @@ default IntrospectedBeanDefinition introspectBeanDefinition(BeanReference refere
 	 */
 	IntrospectedBeanDefinition introspectBeanDefinition(String beanName);
 
+	InstantiationCreator instantiationCreator(TypeReference typeReference);
+
+	default AotTypeConfiguration typeConfiguration(ResolvableType resolvableType) {
+		return typeConfiguration(resolvableType.toClass());
+	}
+
+	default AotTypeConfiguration typeConfiguration(Class<?> type) {
+		return typeConfiguration(TypeReference.of(type));
+	}
+
+	AotTypeConfiguration typeConfiguration(TypeReference typeReference);
+
+	Collection<AotTypeConfiguration> typeConfigurations();
+
 	/**
 	 * Type-based introspector to resolve {@link Class} from a type name and to introspect the bean factory for presence
 	 * of beans.
@@ -286,7 +303,6 @@ default void ifTypePresent(Consumer<Class<?>> action) {
 		 * @return a {@link List} of bean names. The list is empty if the bean factory does not hold any beans of this type.
 		 */
 		List<String> getBeanNames();
-
 	}
 
 	/**
@@ -340,7 +356,11 @@ interface IntrospectedBeanDefinition {
 		 */
 		@Nullable
 		Class<?> resolveType();
+	}
 
+	interface InstantiationCreator {
+		boolean isAvailable();
+		void create();
 	}
 
 }

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

@@ -15,6 +15,8 @@
  */
 package org.springframework.data.aot;
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mapping.context.AbstractMappingContext;
@@ -26,6 +28,7 @@
 import org.springframework.data.mapping.model.PersistentEntityClassInitializer;
 import org.springframework.data.mapping.model.Property;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
+import org.springframework.data.repository.aot.generate.RepositoryContributor;
 import org.springframework.data.util.TypeInformation;
 
 /**
@@ -34,9 +37,12 @@
  * @author Mark Paluch
  * @since 4.0
  */
-public class AotMappingContext extends
+class AotMappingContext extends // TODO: hide this one and delegate to other component - can we use the
+																				// AotContext for it?
 		AbstractMappingContext<BasicPersistentEntity<?, AotMappingContext.BasicPersistentProperty>, AotMappingContext.BasicPersistentProperty> {
 
+	private static final Log logger = LogFactory.getLog(AotMappingContext.class);
+
 	private final EntityInstantiators instantiators = new EntityInstantiators();
 	private final ClassGeneratingPropertyAccessorFactory propertyAccessorFactory = new ClassGeneratingPropertyAccessorFactory();
 
@@ -55,15 +61,18 @@ public void contribute(PersistentEntity<?, ?> entity) {
 		propertyAccessorFactory.initialize(entity);
 	}
 
+	// TODO: can we extract some util for this using only type
 	@Override
 	protected <T> BasicPersistentEntity<?, BasicPersistentProperty> createPersistentEntity(
 			TypeInformation<T> typeInformation) {
+		logger.debug("I hate gradle: create persistent entity for type: " + typeInformation);
 		return new BasicPersistentEntity<>(typeInformation);
 	}
 
 	@Override
 	protected BasicPersistentProperty createPersistentProperty(Property property,
 			BasicPersistentEntity<?, BasicPersistentProperty> owner, SimpleTypeHolder simpleTypeHolder) {
+		logger.info("creating property: " + property.getName());
 		return new BasicPersistentProperty(property, owner, simpleTypeHolder);
 	}
 
@@ -74,10 +83,21 @@ public BasicPersistentProperty(Property property, PersistentEntity<?, BasicPersi
 			super(property, owner, simpleTypeHolder);
 		}
 
+		@Override
+		public boolean isAssociation() {
+			return false;
+		}
+
 		@Override
 		protected Association<BasicPersistentProperty> createAssociation() {
-			return null;
+			return new Association<>(this, null);
 		}
+
+		@Override
+		public Association<BasicPersistentProperty> getRequiredAssociation() {
+			return new Association<>(this, null);
+		}
+
 	}
 
 }

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

@@ -0,0 +1,110 @@
+/*
+ * 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
+ *
+ *      http://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.aot;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+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;
+
+/**
+ * @author Christoph Strobl
+ */
+public interface AotTypeConfiguration {
+
+	AotTypeConfiguration forDataBinding();
+
+	AotTypeConfiguration forReflectiveAccess(MemberCategory... categories);
+
+	AotTypeConfiguration generateEntityInstantiator();
+
+	// TODO: ? should this be a global condition for the entire configuration or do we need it for certain aspects ?
+	AotTypeConfiguration conditional(Predicate<TypeReference> filter);
+
+	default AotTypeConfiguration usedAsProjectionInterface() {
+		return proxyInterface(TargetAware.class, SpringProxy.class, DecoratingProxy.class);
+	}
+
+	default AotTypeConfiguration springProxy() {
+		return proxyInterface(SpringProxy.class, Advised.class, DecoratingProxy.class);
+	}
+
+	default AotTypeConfiguration repositoryProxy() {
+
+		springProxy();
+
+		List<TypeReference> transactionalProxy = List.of(TypeReference.of("org.springframework.data.repository.Repository"),
+				TypeReference.of("org.springframework.transaction.interceptor.TransactionalProxy"),
+				TypeReference.of("org.springframework.aop.framework.Advised"), TypeReference.of(DecoratingProxy.class));
+		proxyInterface(transactionalProxy);
+
+		proxyInterface(
+				Stream.concat(transactionalProxy.stream(), Stream.of(TypeReference.of(Serializable.class))).toList());
+
+		return this;
+	}
+
+	AotTypeConfiguration proxyInterface(List<TypeReference> proxyInterfaces);
+
+	default AotTypeConfiguration proxyInterface(TypeReference... proxyInterfaces) {
+		return proxyInterface(List.of(proxyInterfaces));
+	}
+
+	default AotTypeConfiguration proxyInterface(Class<?>... proxyInterfaces) {
+		return proxyInterface(Stream.of(proxyInterfaces).map(TypeReference::of).toList());
+	}
+
+	AotTypeConfiguration forQuerydsl();
+
+	void contribute(GenerationContext generationContext);
+
+	static Predicate<TypeReference> userConfiguredCondition(Environment environment) {
+
+		return new Predicate<TypeReference>() {
+
+			private final List<String> allowedAccessorTypes = environment.getProperty("spring.data.aot.generate.accessor",
+					List.class, List.of());
+
+			@Override
+			@SuppressWarnings("unchecked")
+			public boolean test(TypeReference typeReference) {
+
+				if (!allowedAccessorTypes.isEmpty()) {
+					if (allowedAccessorTypes.contains("none") || allowedAccessorTypes.contains("false")
+							|| allowedAccessorTypes.contains("off")) {
+						return false;
+					}
+					if (!allowedAccessorTypes.contains(typeReference.getName())) {
+						return false;
+					}
+				}
+
+				return true;
+			}
+		};
+	}
+
+}