Polishing.

Move off TypeReference for known and loaded classes for easier handling. Introduce configuration for enabled and include/exclude filters. Refactor configuration to functional style.

Original Pull Request: #3318

Author: mp911de

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

@@ -22,7 +22,6 @@
 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;
@@ -230,18 +229,31 @@ 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));
+	/**
+	 * Obtain a {@link AotTypeConfiguration} for the given {@link ResolvableType} to customize the AOT processing for the
+	 * given type.
+	 *
+	 * @param resolvableType the resolvable type to configure.
+	 * @param configurationConsumer configuration consumer function.
+	 */
+	default void typeConfiguration(ResolvableType resolvableType, Consumer<AotTypeConfiguration> configurationConsumer) {
+		typeConfiguration(resolvableType.toClass(), configurationConsumer);
 	}
 
-	AotTypeConfiguration typeConfiguration(TypeReference typeReference);
+	/**
+	 * Obtain a {@link AotTypeConfiguration} for the given {@link ResolvableType} to customize the AOT processing for the
+	 * given type.
+	 *
+	 * @param type the type to configure.
+	 * @param configurationConsumer configuration consumer function.
+	 */
+	void typeConfiguration(Class<?> type, Consumer<AotTypeConfiguration> configurationConsumer);
 
+	/**
+	 * Return all type configurations registered with this {@link AotContext}.
+	 *
+	 * @return all type configurations registered with this {@link AotContext}.
+	 */
 	Collection<AotTypeConfiguration> typeConfigurations();
 
 	/**
@@ -358,9 +370,4 @@ interface IntrospectedBeanDefinition {
 		Class<?> resolveType();
 	}
 
-	interface InstantiationCreator {
-		boolean isAvailable();
-		void create();
-	}
-
 }

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

@@ -24,8 +24,8 @@
 import org.springframework.data.mapping.model.BasicPersistentEntity;
 import org.springframework.data.mapping.model.ClassGeneratingPropertyAccessorFactory;
 import org.springframework.data.mapping.model.EntityInstantiator;
+import org.springframework.data.mapping.model.EntityInstantiatorSource;
 import org.springframework.data.mapping.model.EntityInstantiators;
-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;
@@ -37,48 +37,53 @@
  * @author Mark Paluch
  * @since 4.0
  */
-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> {
+class AotMappingContext extends
+		AbstractMappingContext<BasicPersistentEntity<?, AotMappingContext.AotPersistentProperty>, AotMappingContext.AotPersistentProperty> {
 
 	private static final Log logger = LogFactory.getLog(AotMappingContext.class);
 
 	private final EntityInstantiators instantiators = new EntityInstantiators();
-	private final ClassGeneratingPropertyAccessorFactory propertyAccessorFactory = new ClassGeneratingPropertyAccessorFactory();
+	private final AotAccessorFactory propertyAccessorFactory = new AotAccessorFactory();
 
 	/**
 	 * Contribute entity instantiators and property accessors for the given {@link PersistentEntity} that are captured
 	 * through Spring's {@code CglibClassHandler}. Otherwise, this is a no-op if contributions are not ran through
 	 * {@code CglibClassHandler}.
 	 *
-	 * @param entity
+	 * @param entityType
 	 */
-	public void contribute(PersistentEntity<?, ?> entity) {
-		EntityInstantiator instantiator = instantiators.getInstantiatorFor(entity);
-		if (instantiator instanceof PersistentEntityClassInitializer pec) {
-			pec.initialize(entity);
+	public void contribute(Class<?> entityType) {
+
+		BasicPersistentEntity<?, AotPersistentProperty> entity = getPersistentEntity(entityType);
+
+		if (entity != null) {
+
+			EntityInstantiator instantiator = instantiators.getInstantiatorFor(entity);
+			if (instantiator instanceof EntityInstantiatorSource source) {
+				source.getInstantiatorFor(entity);
+			}
+
+			propertyAccessorFactory.initialize(entity);
 		}
-		propertyAccessorFactory.initialize(entity);
 	}
 
-	// TODO: can we extract some util for this using only type
 	@Override
-	protected <T> BasicPersistentEntity<?, BasicPersistentProperty> createPersistentEntity(
+	protected <T> BasicPersistentEntity<?, AotPersistentProperty> 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) {
+	protected AotPersistentProperty createPersistentProperty(Property property,
+			BasicPersistentEntity<?, AotPersistentProperty> owner, SimpleTypeHolder simpleTypeHolder) {
 		logger.info("creating property: " + property.getName());
-		return new BasicPersistentProperty(property, owner, simpleTypeHolder);
+		return new AotPersistentProperty(property, owner, simpleTypeHolder);
 	}
 
-	static class BasicPersistentProperty extends AnnotationBasedPersistentProperty<BasicPersistentProperty> {
+	static class AotPersistentProperty extends AnnotationBasedPersistentProperty<AotPersistentProperty> {
 
-		public BasicPersistentProperty(Property property, PersistentEntity<?, BasicPersistentProperty> owner,
+		public AotPersistentProperty(Property property, PersistentEntity<?, AotPersistentProperty> owner,
 				SimpleTypeHolder simpleTypeHolder) {
 			super(property, owner, simpleTypeHolder);
 		}
@@ -89,15 +94,22 @@ public boolean isAssociation() {
 		}
 
 		@Override
-		protected Association<BasicPersistentProperty> createAssociation() {
+		protected Association<AotPersistentProperty> createAssociation() {
 			return new Association<>(this, null);
 		}
 
 		@Override
-		public Association<BasicPersistentProperty> getRequiredAssociation() {
+		public Association<AotPersistentProperty> getAssociation() {
 			return new Association<>(this, null);
 		}
 
 	}
 
+	static class AotAccessorFactory extends ClassGeneratingPropertyAccessorFactory {
+
+		public void initialize(PersistentEntity<?, ?> entity) {
+			potentiallyCreateAndRegisterPersistentPropertyAccessorClass(entity);
+		}
+	}
+
 }

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

@@ -39,10 +39,10 @@ public interface AotTypeConfiguration {
 
 	AotTypeConfiguration forReflectiveAccess(MemberCategory... categories);
 
-	AotTypeConfiguration generateEntityInstantiator();
+	AotTypeConfiguration contributeAccessors();
 
 	// TODO: ? should this be a global condition for the entire configuration or do we need it for certain aspects ?
-	AotTypeConfiguration conditional(Predicate<TypeReference> filter);
+	AotTypeConfiguration filter(Predicate<Class<?>> filter);
 
 	default AotTypeConfiguration usedAsProjectionInterface() {
 		return proxyInterface(TargetAware.class, SpringProxy.class, DecoratingProxy.class);
@@ -69,42 +69,12 @@ default AotTypeConfiguration repositoryProxy() {
 
 	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;
-			}
-		};
-	}
+	void contribute(Environment environment, GenerationContext generationContext);
 
 }